﻿/*
* OSPE - Open Source Packet Editor
* Copyright(C) 2018-2019 Javier Pereda <https://github.com/elecyb>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using OSPE;

namespace OPSE_HotKeys
{
public sealed class KeyboardHook : IDisposable
{
#region class methods
    // Registers a hot key with Windows.
    [DllImport("user32.dll")]
    private static extern bool RegisterHotKey(IntPtr hWnd, int id, uint fsModifiers, uint vk);
    // Unregisters the hot key with Windows.
    [DllImport("user32.dll")]
    private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
    /// <summary>
    /// Represents the window that is used internally to get the messages.
    /// </summary>
    private class Window : NativeWindow, IDisposable
    {
        private static int WM_HOTKEY = 0x0312;

        public Window()
        {
            // create the handle for the window.
            this.CreateHandle(new CreateParams());
        }

        /// <summary>
        /// Overridden to get the notifications.
        /// </summary>
        /// <param name="m"></param>
        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            // check if we got a hot key pressed.
            if (m.Msg == WM_HOTKEY)
            {
                // get the keys.
                Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);
                ModKeys modifier = (ModKeys)((int)m.LParam & 0xFFFF);

                // invoke the event to notify the parent.
                if (KeyPressed != null)
                    KeyPressed(this, new KeyPressedEventArgs(modifier, key));
            }
        }

        public event EventHandler<KeyPressedEventArgs> KeyPressed;

        #region IDisposable Members

        public void Dispose()
        {
            this.DestroyHandle();
        }

        #endregion
    }

    private Window _window = new Window();
    private int _currentId;

    public KeyboardHook()
    {
        // register the event of the inner native window.
        _window.KeyPressed += delegate(object sender, KeyPressedEventArgs args)
        {
            if (KeyPressed != null)
                KeyPressed(this, args);
        };
    }
#endregion
    /// <summary>
    /// Registers a hot key in the system.
    /// </summary>
    /// <param name="modifier">The modifiers that are associated with the hot key.</param>
    /// <param name="key">The key itself that is associated with the hot key.</param>
    public void RegisterHotKey(ModKeys modifier, Keys key)
    {
        // increment the counter.
        _currentId = _currentId + 1;

        // register the hot key.
        if (!RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key))
            throw new InvalidOperationException("Couldn’t register the hot key.");
    }

    /// <summary>
    /// A hot key has been pressed.
    /// </summary>
    public event EventHandler<KeyPressedEventArgs> KeyPressed;

    public void Dispose()
    {
        // unregister all the registered hot keys.
        for (int i = _currentId; i > 0; i--)
        {
            UnregisterHotKey(_window.Handle, i);
        }

        // dispose the inner native window.
        _window.Dispose();
    }
}

    /// <summary>
    /// Event Args for the event that is fired after the hot key has been pressed.
    /// </summary>
    public class KeyPressedEventArgs : EventArgs
    {
        private ModKeys _modifier;
        private Keys _key;

        internal KeyPressedEventArgs(ModKeys modifier, Keys key)
        {
            _modifier = modifier;
            _key = key;
        }

        public ModKeys Modifier
        {
            get { return _modifier; }
        }

        public Keys Key
        {
            get { return _key; }
        }
    }

    /// <summary>
    /// The enumeration of possible modifiers.
    /// </summary>
    [Flags]
    public enum ModKeys : uint
    {
        Alt = 1,
        Control = 2,
        Shift = 4,
        Win = 8
    }


    public class HotKeys
    {
        public static KeyboardHook searchNextKeyboardHook;
        public static KeyboardHook startCaptureKeyboardHook;
        public static KeyboardHook stopCaptureKeyboardHook;
        public static KeyboardHook normalFilterKeyboardHook;
        public static KeyboardHook customFilterKeyboardHook;
        public static KeyboardHook selectProcessKeyboardHook;
        public static KeyboardHook injectLastKeyboardHook;

        /// <summary>
        /// Convierte de Keys a ModKeys para ser usado con la funcion RegisterHotKey
        /// </summary>
        public static ModKeys ToModKeys(Keys k)
        {
            ModKeys mods = 0x0;
            if (k.HasFlag(Keys.Control))
                mods |= ModKeys.Control;
            if (k.HasFlag(Keys.Shift))
                mods |= ModKeys.Shift;
            if (k.HasFlag(Keys.Alt))
                mods |= ModKeys.Alt;

            return mods;
        }

        // Keyboard Hooks

        public static void hook_StartCapture(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionStartCapture();
        }

        public static void hook_StopCapture(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionPauseCapture();
        }

        public static void hook_NormalFilter(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionStartStopFiltering(true);
        }

        public static void hook_CustomFilter(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionStartStopScript(true);
        }

        public static void hook_SelectProcess(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionSelectProcess();
        }

        public static void hook_InjectLast(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionInjectLastProcess();
        }

        public static void hook_SearchNext(object sender, KeyPressedEventArgs e)
        {
            Program.mainForm.ActionSearchNext();
        }
    }
}
